<!doctype html>

<html lang="en">
<head>
    <meta charset="utf-8" />
    <title>Java Topics</title>

    <script type="text/javascript" src="jq.js"><!--//--></script>
    <link rel="stylesheet" href="css/hot-sneaks/jq-ui-1.9.min.css" />

    <style type="text/css">
        html, body {
            height: 100%;
            margin: 0px;
        }

        body {
            height: auto;
        }

        body {
            font-family: "Trebuchet MS", "Helvetica", "Arial",  "Verdana", "sans-serif";
            font-size: 66%;
            background: #add8e6;
        }

        #main {
            margin: 150px;
        }

        ul.ui-tabs-nav {
            -webkit-user-select: none;
        }

        li.ui-state-active a.ui-tabs-anchor {
            cursor: default !important;
        }

        #tabs {
            height: 95%;
            margin: 0 8px;
            position: relative;
            top: 5px;
        }

        /* wiki */
        table.wikitable {
            margin: 1em 0;
            background-color: #F9F9F9;
            border: 1px #AAA solid;
            border-collapse: collapse;
            color: black;
            font-size: 100%;
        }

        table.wikitable > tr > th, table.wikitable > tr > td, table.wikitable > * > tr > th, table.wikitable > * > tr > td {
            border: 1px #AAA solid;
            padding: 0.2em;
        }

        table.wikitable > tr > th, table.wikitable > * > tr > th {
            background-color: #F2F2F2;
            text-align: center;
        }
    </style>
</head>
<body>

<div id="tabs">
    <ul>
        <li><a href="#tabs-jc">Java Core</a></li>
        <li><a href="#tabs-mt">Multithreading</a></li>
        <li><a href="#tabs-io">I\O</a></li>
        <li><a href="#tabs-nio">NIO</a></li>
        <li><a href="#tabs-gc">GC</a></li>
        <li><a href="#tabs-jweb">Java web</a></li>
        <li><a href="#tabs-jdbc">JDBC</a></li>
        <li><a href="#tabs-jms">JMS</a></li>
        <li><a href="#tabs-spr">Spring</a></li>
        <li><a href="#tabs-sql">SQL</a></li>
        <li><a href="#tabs-js">JavaScript</a></li>
        <li><a href="#tabs-dp">Design patterns</a></li>
    </ul>

    <div id="tabs-jc">
        <p>This part covers Java core.</p>
        <div class="accordion">
            <h3>Collections</h3>
            <div>
                <p>.</p>
            </div>
            <h3>Exceptions</h3>
            <div>
                <p>.</p>
            </div>
            <h3>Section 3</h3>
            <div>
                <p>.</p>
                <ul>
                    <li>Item 1</li>
                    <li>Item 2</li>
                    <li>Item 3</li>
                </ul>
            </div>
        </div>
    </div>

    <div id="tabs-mt">
        <p>.</p>
    </div>

    <div id="tabs-io">
        <p>.</p>
    </div>

    <div id="tabs-nio">
        <p>.</p>
    </div>

    <!-- Garbage Collector -->
    <div id="tabs-gc">
        <p>Некторые схемы работы:</p>
        <ul style="text-align: left;">
            <li>схема "<b>подсчет ссылок</b>".<br>
                Довольно медленный способ реализации GC - с каждым объектом храниться счетчик ссылок на него. При выходе ссылки из области видимости счетчик уменьшается, при создании ссылки - увеличивается.
                Когда он равен 0 - объект убирается из памяти.
                Метод плох тем, что решение задачи циклических ссылок является ресурсоемкой
                операцией. Возможно поэтому данный метод не применяется ни в одной из JVM</li>
            <li>схема "<b>остановиться и скопировать</b>".<br>
                Работа приложения приостанавливается и GC копирует все объекты на которые есть живые ссылки из одной кучи в другую.
                Таким образом мы получаем дефрагментированый участок памяти с живыми объектами и кучу с мусором, который можно уничтожить.
                Недостатками такого подхода являются неэффективное использование памяти и необходимость останавлиать программу и копировать память даже в том случае, если приложение вошло в стабильный режим работы и уже практически не создает и не удаляет объекты</li>
            <li>схема "<b>пометить и убрать</b>".<br>
                Похожа на предыдущую.
                GC сканирует память и помечает неиспользуемые объекты, но не удаляет их сразу. Удаление происходит в конце процесса сканирования. Потом происходит дефрагментация памяти.</li>
        </ul>
        <p></p>
        <p>Память в Java:</p>
        <p>The Permanent Generation

            Permanent generation используется только JVM для хранения необходимых данных, в том числе метаданные о созданных объектах.
            При каждом создании объекта JVM будет «класть» некоторый набор данных в PG. Соответственно, чем больше вы создаете объектов разных типов, тем больше «жилого пространства» требуется в PG. </p>


        Heap


        Heap – основной сегмент памяти, где хранятся все ваши объекты. Heap делится на два подсегмента, Old Generation и New Generation. New Generation в свою очередь делится на Eden и два сегмента Survivor.
        <p></p>
        <p>Ссылки:</p>
        <p><a href="http://j4sq.blogspot.ru/2012/01/java-junior.html">http://j4sq.blogspot.ru/2012/01/java-junior.html</a></p>
        <p><a href="http://www.ibm.com/developerworks/ru/library/j-jtp11253/">http://www.ibm.com/developerworks/ru/library/j-jtp11253/</a></p>
    </div>

    <!-- WEB -->
    <div id="tabs-jweb">
        <p>Ссылки:</p>
        <p><a href="http://ru.wikipedia.org/wiki/HTTP">http://ru.wikipedia.org/wiki/HTTP</a></p>
    </div>

    <!-- . -->
    <div id="tabs-jdbc">
        <p>.</p>
    </div>

    <!-- JMS -->
    <div id="tabs-jms">
        <div>
            <p><b>Java Message Service (JMS)</b>&nbsp;—
            стандарт промежуточного ПО для рассылки сообщений,
            позволяющий приложениям, выполненным на платформе J2EE, создавать, посылать,
            получать и читать сообщения. Коммуникация между компонентами, использующими JMS, асинхронна (процедура не
            дожидается ответа на своё сообщение) и независима от исполнения компонентов.</p>

            <p>JMS поддерживает две модели обмена сообщениями: «<b>от пункта к пункту</b>» и «<b>издатель-подписчик</b>».</p>

            <p>Модель «<b>от пункта к пункту</b>» характеризуется следующим:</p>
            <ul>
                <li>Каждое сообщение имеет только одного адресата</li>
                <li>Сообщение попадает в «почтовый ящик», или «очередь» адресата и
                    может быть прочитано когда угодно. Если адресат не работал в момент отсылки сообщения, сообщение не
                    пропадёт.
                </li>
                <li>После получения сообщения адресат посылает извещение.</li>
            </ul>
            <p>Модель «<b>издатель-подписчик</b>» характеризуется следующим:</p>
            <ul>
                <li>Подписчик подписывается на определённую «тему»</li>
                <li>Издатель публикует своё сообщение. Его получают все подписчики этой темы</li>
                <li>Получатель должен работать и быть подписан в момент отправки сообщения</li>
            </ul>
        </div>
    </div>

    <div id="tabs-spr">
        <p>.</p>
    </div>

    <!-- SQL -->
    <div id="tabs-sql">
        <h3>Операторы</h3>
        <p>Операторы SQL делятся на:</p>
        <ul>
            <li>операторы определения данных (<i><span lang="en" xml:lang="en">Data Definition Language, <b>DDL</b></span></i>)
                <ul>
                    <li><b>CREATE</b> создает объект БД (саму базу, таблицу, <b>представление</b>, пользователя и&#160;т.&#160;д.)</li>
                    <li><b>ALTER</b> изменяет объект</li>
                    <li><b>DROP</b> удаляет объект</li>
                </ul>
            </li>
            <li>операторы манипуляции данными (<i><span lang="en" xml:lang="en">Data Manipulation Language, <b>DML</b></span></i>)
                <ul>
                    <li><b>SELECT</b> считывает данные, удовлетворяющие заданным условиям</li>
                    <li><b>INSERT</b> добавляет новые данные</li>
                    <li><b>UPDATE</b> изменяет существующие данные</li>
                    <li><b>DELETE</b> удаляет данные</li>
                </ul>
            </li>
            <li>операторы определения доступа к данным (<i><span lang="en" xml:lang="en">Data Control Language, <b>DCL</b></span></i>)
                <ul>
                    <li><b>GRANT</b> предоставляет пользователю (группе) разрешения на определенные операции с объектом</li>
                    <li><b>REVOKE</b> отзывает ранее выданные разрешения</li>
                    <li><b>DENY</b> задает запрет, имеющий приоритет над разрешением</li>
                </ul>
            </li>
            <li>операторы управления <b>транзакциями</b> (<i><span lang="en" xml:lang="en">Transaction Control Language, <b>TCL</b></span></i>)
                <ul>
                    <li><b>COMMIT</b> применяет транзакцию.</li>
                    <li><b>ROLLBACK</b> откатывает все изменения, сделанные в контексте текущей транзакции.</li>
                    <li><b>SAVEPOINT</b> делит транзакцию на более мелкие участки.</li>
                </ul>
            </li>
        </ul>

        <h3>Уровни изоляции</h3>

        <p>Стандарт SQL-92 определяет уровни изоляции, установка которых предотвращает определенные конфликтные ситуации. Введены следующие четыре уровня изоляции:</p>

        <ul>
            <li><b>Serializable (упорядочиваемость)</b><br>
                <div>Самый высокий уровень изолированности; транзакции полностью изолируются друг от друга.</div>
                <div>На этом уровне результаты параллельного выполнения транзакций для базы данных в большинстве случаев можно считать совпадающими с последовательным выполнением тех же транзакций (по очереди в каком-либо порядке).</div>
            </li>
            <li><b>Repeatable read (повторяемость чтения)</b><br>
                <div>Уровень, при котором чтение одной и той же строки или строк в транзакции дает одинаковый результат.</div>
                <div>(Пока транзакция не завершена, никакие другие транзакции не могут модифицировать эти данные.)</div>
            </li>
            <li><b>Read committed (чтение фиксированных данных)</b><br>
                <div>Принятый по умолчанию уровень для Microsoft SQL Server. Завершенное чтение, при котором отсутствует черновое, "грязное" чтение.</div>
                <div>(т.е. чтение одним пользователем данных, которые не были зафиксированы в БД командой COMMIT)</div>
                <div>Тем не менее в процессе работы одной транзакции другая может быть успешно завершена и сделанные ею изменения зафиксированы.</div>
                <div>В итоге первая транзакция будет работать с другим набором данных. Это проблема неповторяемого чтения.</div>
            </li>
            <li><b>Read uncommitted (чтение незафиксированных данных)</b><br>
                <div>Низший уровень изоляции, соответствующий уровню 0. Он гарантирует только отсутствие потерянных обновлений. </div>
                <div>Если несколько транзакций одновременно пытались изменять одну и ту же строку, то в окончательном варианте строка будет иметь значение, определенное последней успешно выполненной транзакцией.</div>
            </li>
        </ul>
    </div>

    <!-- . -->
    <div id="tabs-js">
        <p>.</p>
    </div>

    <div id="tabs-dp">
    <table class="wikitable">
        <tbody>
        <tr>
            <th>Название</th>
            <th>Оригинальное название</th>
            <th>Описание</th>
        </tr>
        <tr>
            <td colspan="3" style="background:#EEEEFF"><b>Основные шаблоны (Fundamental)</b></td>
        </tr>
        <tr>
            <td>Шаблон делегирования</td>
            <td>Delegation pattern</td>
            <td>Объект внешне выражает некоторое поведение, но в реальности передаёт ответственность за выполнение этого поведения связанному объекту</td>
        </tr>
        <tr>
            <td>Неизменяемый объект</td>
            <td>Immutable</td>
            <td>Объект, который не может быть изменён после своего создания</td>
        </tr>
        <tr>
            <td>Помечающий интерфейс</td>
            <td>Marker interface</td>
            <td>Интерфейс, не определяющий никаких методов, а только помечающий класс как определяющий некую логику</td>
        </tr>
        <tr>
            <td colspan="3" style="background:#EEEEFF"><b>Порождающие шаблоны (Creational)</b> — шаблоны проектирования, которые абстрагируют процесс
                инстанцирования. Они позволяют сделать систему независимой от способа создания, композиции и представления
                объектов. Шаблон, порождающий классы, использует наследование, чтобы изменять инстанцируемый класс, а
                шаблон, порождающий объекты, делегирует инстанцирование другому объекту.
            </td>
        </tr>
        <tr>
            <td>Абстрактная фабрика</td>
            <td>Abstract factory</td>
            <td>Класс, который представляет собой интерфейс для создания компонентов системы.</td>
        </tr>
        <tr>
            <td>Строитель</td>
            <td>Builder</td>
            <td>Класс, который представляет собой интерфейс для создания сложного объекта</td>
        </tr>
        <tr>
            <td>Фабричный метод</td>
            <td>Factory method</td>
            <td>Определяет интерфейс для создания объекта, но оставляет подклассам решение о том, какой класс инстанциировать</td>
        </tr>
        <tr>
            <td>Отложенная инициализация</td>
            <td>Lazy initialization</td>
            <td>Объект, инициализируемый во время первого обращения к нему</td>
        </tr>
        <tr>
            <td>Пул одиночек</td>
            <td>Multiton</td>
            <td>Гарантирует, что класс имеет поименованные экземпляры объекта и обеспечивает глобальную точку доступа к ним</td>
        </tr>
        <tr>
            <td>Объектный пул</td>
            <td>Object pool</td>
            <td>Класс, который представляет собой интерфейс для работы с набором инициализированных и готовых к использованию объектов</td>
        </tr>
        <tr>
            <td>Прототип</td>
            <td>Prototype</td>
            <td>Определяет интерфейс создания объекта через клонирование другого объекта вместо создания через конструктор</td>
        </tr>
        <tr>
            <td>Одиночка</td>
            <td>Singleton</td>
            <td>Класс, который может иметь только один экземпляр.</td>
        </tr>
        <tr>
            <td colspan="3" style="background:#EEEEFF"><b>Структурные шаблоны (Structural)</b> определяют различные сложные структуры, которые
                изменяют интерфейс уже существующих
                объектов или его реализацию, позволяя облегчить разработку и оптимизировать программу.
            </td>
        </tr>
        <tr>
            <td>Адаптер</td>
            <td>Adapter / Wrapper</td>
            <td>Объект, обеспечивающий взаимодействие двух других объектов, один из которых использует, а другой предоставляет несовместимый с первым интерфейс</td>
        </tr>
        <tr>
            <td>Мост</td>
            <td>Bridge</td>
            <td>Структура, позволяющая изменять интерфейс обращения и интерфейс реализации класса независимо</td>
        </tr>
        <tr>
            <td>Компоновщик</td>
            <td>Composite</td>
            <td>Объект, который объединяет в себе объекты, подобные ему самому</td>
        </tr>
        <tr>
            <td>Декоратор или Обёртка</td>
            <td>Decorator</td>
            <td>Класс, расширяющий функциональность другого класса без использования наследования</td>
        </tr>
        <tr>
            <td>Фасад</td>
            <td>Facade</td>
            <td>Объект, который абстрагирует работу с несколькими классами, объединяя их в единое целое</td>
        </tr>
        <tr>
            <td>Единая точка входа</td>
            <td>Front Controller</td>
            <td>Обеспечивает унифицированный интерфейс для интерфейсов в подсистеме. Front Controller определяет
                высокоуровневый интерфейс, упрощающий использование подсистемы
            </td>
        </tr>
        <tr>
            <td>Приспособленец</td>
            <td>Flyweight</td>
            <td>Это объект, представляющий себя как уникальный экземпляр в разных местах программы, но по факту не являющийся таковым</td>
        </tr>
        <tr>
            <td>Заместитель</td>
            <td>Proxy</td>
            <td>Объект, который является посредником между двумя другими объектами, и который реализовывает/ограничивает
                доступ к объекту, к которому обращаются через него
            </td>
        </tr>
        <tr>
            <td colspan="3" style="background:#EEEEFF"><b>Поведенческие шаблоны (Behavioral)</b> определяют взаимодействие между объектами, увеличивая
                таким образом его гибкость.
            </td>
        </tr>
        <tr>
            <td>Цепочка ответственности</td>
            <td>Chain of responsibility</td>
            <td>Предназначен для организации в системе уровней ответственности</td>
        </tr>
        <tr>
            <td>Команда, Action, Transaction</td>
            <td>Command</td>
            <td>Представляет действие. Объект команды заключает в себе само действие и его параметры</td>
        </tr>
        <tr>
            <td>Интерпретатор</td>
            <td>Interpreter</td>
            <td>Решает часто встречающуюся, но подверженную изменениям, задачу</td>
        </tr>
        <tr>
            <td>Итератор</td>
            <td>Iterator, Cursor</td>
            <td>Представляет собой объект, позволяющий получить последовательный доступ к элементам объекта-агрегата без
                использования описаний каждого из объектов, входящий в состав агрегации
            </td>
        </tr>
        <tr>
            <td>Посредник</td>
            <td>Mediator</td>
            <td>Обеспечивает взаимодействие множества объектов, формируя при этом слабую связанность и избавляя объекты от
                необходимости явно ссылаться друг на друга
            </td>
        </tr>
        <tr>
            <td>Хранитель</td>
            <td>Memento</td>
            <td>Позволяет не нарушая инкапсуляцию зафиксировать и сохранить внутреннее состояния объекта так, чтобы позднее
                восстановить его в этом состоянии
            </td>
        </tr>
        <tr>
            <td>Пустой объект</td>
            <td>Null object</td>
            <td>Предотвращает нулевые указатели, предоставляя объект «по умолчанию»</td>
        </tr>
        <tr>
            <td>Наблюдатель</td>
            <td>Observer или Publish/subscribe</td>
            <td>Определяет зависимость типа «один ко многим» между объектами таким образом, что при изменении состояния
                одного объекта все зависящие от него оповещаются об этом событии
            </td>
        </tr>
        <tr>
            <td>Стратегия</td>
            <td>Strategy</td>
            <td>Предназначен для определения семейства алгоритмов, инкапсуляции каждого из них и обеспечения их
                взаимозаменяемости</td>
        </tr>
        <tr>
            <td>Шаблонный метод</td>
            <td>Template method</td>
            <td>Определяет основу алгоритма и позволяет наследникам переопределять некоторые шаги алгоритма, не изменяя его
                структуру в целом.
            </td>
        </tr>
        <tr>
            <td>Посетитель</td>
            <td>Visitor</td>
            <td>Описывает операцию, которая выполняется над объектами других классов. При изменении класса Visitor нет
                необходимости изменять обслуживаемые классы.
            </td>
        </tr>
        </tbody>
    </table>
    </div>
</div>

<div id="main">
    <div id="accordion">
        <h3>Section 1</h3>
        <div>
            <p>
                Mauris mauris ante, blandit et, ultrices a, suscipit eget, quam. Integer
                ut neque. Vivamus nisi metus, molestie vel, gravida in, condimentum sit
                amet, nunc. Nam a nibh. Donec suscipit eros. Nam mi. Proin viverra leo ut
                odio. Curabitur malesuada. Vestibulum a velit eu ante scelerisque vulputate.
            </p>
        </div>
        <h3>Section 2</h3>
        <div>
            <p>
                Sed non urna. Donec et ante. Phasellus eu ligula. Vestibulum sit amet
                purus. Vivamus hendrerit, dolor at aliquet laoreet, mauris turpis porttitor
                velit, faucibus interdum tellus libero ac justo. Vivamus non quam. In
                suscipit faucibus urna.
            </p>
        </div>
        <h3>Section 3</h3>
        <div>
            <p>
                Nam enim risus, molestie et, porta ac, aliquam ac, risus. Quisque lobortis.
                Phasellus pellentesque purus in massa. Aenean in pede. Phasellus ac libero
                ac tellus pellentesque semper. Sed ac felis. Sed commodo, magna quis
                lacinia ornare, quam ante aliquam nisi, eu iaculis leo purus venenatis dui.
            </p>
            <ul>
                <li>List item one</li>
                <li>List item two</li>
                <li>List item three</li>
            </ul>
        </div>
        <h3>Section 4</h3>
        <div>
            <p>
                Cras dictum. Pellentesque habitant morbi tristique senectus et netus
                et malesuada fames ac turpis egestas. Vestibulum ante ipsum primis in
                faucibus orci luctus et ultrices posuere cubilia Curae; Aenean lacinia
                mauris vel est.
            </p>
            <p>
                Suspendisse eu nisl. Nullam ut libero. Integer dignissim consequat lectus.
                Class aptent taciti sociosqu ad litora torquent per conubia nostra, per
                inceptos himenaeos.
            </p>
        </div>
    </div>
</div>

<script type="text/javascript">
    $(function() {
        $(".accordion").accordion({
            heightStyle: "content"
        });

        $("#main").hide();

        $("#tabs").tabs();
    });
</script>

</body>
</html>